<?/* PHP Installer created 10-29-2008 15:10:42 */
$o=array("YXBwbGljYXRpb24ueG1s"=>"PD94bWwgdmVyc2lvbj0iMS4wIj8+CjxkYXRhYmFzZXM+Cgk8IS0tPGRhdGFiYXNlIG5hbWU9ImRiMTA2MjI4MTQyIiBzZXJ2ZXI9ImRiMTA0LnBlcmZvcmEubmV0IiB1c2VybmFtZT0iZGJvMTA2MjI4MTQyIiBwYXNzd29yZD0iVmRzVS5INUUiLz4KCTxkYXRhYmFzZSBuYW1lPSJkYjI2MTQzMTA2OCIgc2VydmVyPSJkYjE3MDcucGVyZm9yYS5uZXQiIHVzZXJuYW1lPSJkYm8yNjE0MzEwNjgiIHBhc3N3b3JkPSJ3SjU4YUZZYyIvPi0tPgo8ZGF0YWJhc2UgbmFtZT0iZGIxMDYyMjgxNDIiIHNlcnZlcj0iZGIxMDQucGVyZm9yYS5uZXQiIHBhc3N3b3JkPSJWZHNVLkg1RSIgdXNlcm5hbWU9ImRibzEwNjIyODE0MiIvPjxkYXRhYmFzZSBuYW1lPSJkYjI2MTQzMTA2OCIgc2VydmVyPSJkYjE3MDcucGVyZm9yYS5uZXQiIHBhc3N3b3JkPSJ3SjU4YUZZYyIgdXNlcm5hbWU9ImRibzI2MTQzMTA2OCIvPjwvZGF0YWJhc2VzPgo=","Y29ubmVjdG9yLnBocA=="=>"<?

function page_load ()
{	
   global $server;
   global $user;
   global $password;
   global $database;
   
	if (isset($HTTP_RAW_POST_DATA)) {                                                                                                                                  
		$input = $HTTP_RAW_POST_DATA;                                                                                                                                  
	} else if (strlen($HTTP_POST_VARS["input"])>0) {                                                                                                                                  
		$input = stripslashes($HTTP_POST_VARS["input"]);                                                                                                                                  
	} else {                                                                                                                                  
		$input = implode("\r\n", file('php://input'));                                                                                                                                  
	}

	$server    = $_GET["server"];
	$user      = $_GET["user"];
	$password  = $_GET["password"];
	$database  = $_GET["database"];
	
	if ($dom=domxml_open_mem($input))                                                                                                                                
	{  
        $o = $dom->document_element();  
		if ($o->node_name() == 'create')
		{
			$path     = $o->get_attribute ('path');
			$server   = $o->get_attribute ('server');
			$user     = $o->get_attribute ('user');
			$password = $o->get_attribute ('password');
			$database = $o->get_attribute ('database');
			echo AddorModifyDatabase ($path, $server, $user, $password, $database);
			exit;
		}
		if ($o->node_name() == 'remove')
		{ 
			$database = $o->get_attribute ('database');
			echo RemoveDatabase ($database);
			exit;
		}
		if ($o->node_name() == 'query')
		{
			$start    = $o->get_attribute ('start');
			$server   = $o->get_attribute ('server');
			$user     = $o->get_attribute ('user');
			$password = $o->get_attribute ('password');
			$database = $o->get_attribute ('database');
			$pagesize = $o->get_attribute ('pagesize');
			if (strlen($pagesize)==0) $pagesize=100;
			$text=$o->get_content ();
			echo OpenObject ($text, $start, $pagesize);
			exit;
		}
	}
	
	$action    = $_GET["action"];
	$table	   = $_GET["table"];
	$start	   = $_GET["start"];
	$key	   = $_GET["key"];
	$path	   = $_GET["path"];
	$name	   = $_GET["name"];
	$value	   = $_GET["value"];
	
	if ($action=='persist')
	{ 
		echo Persist ($name, $value);
	}
	else if ($action=='getpersistance')
	{
		header ('Content-type: text/xml');
		echo GetPersistance ();
	}
	else if ($action=='getobjects')
	{
		header ('Content-type: text/xml');
		echo GetObjects ();
	}
	else if ($action=='getobject')
	{
		header ('Content-type: text/xml');
		echo GetObject ($table);
	}
	else if ($action=='getfile')
	{ 
		echo GetFile ($path);
	}
	else if ($action=='openobject')
	{
		header ('Content-type: text/xml');
		echo OpenObject ('SELECT * FROM ' . $table, $start);
	}
	else if (strlen($action) > 0)
	{
		echo 'action "' . $action . '" not defined';
	}
}

function RemoveDatabase ($name)
{
    $message = array(); 
    $message[] = 'Looking up ' . $name;
    if ( $dom=domxml_open_file('application.xml') )
	{
	    foreach ($dom->get_elements_by_tagname('database') as $database)
        {
            if ($database->get_attribute ('name') == $name)
            { 
                $message[] = 'Deleting up ' . $name;
				$database->unlink_node (); 
            }
        } 
     
        $dom->dump_file ('application.xml');
         $message[] = 'Remove action succeeded!';
        return implode ("\n", $message);
	}
    return 'Could not open configuration file ' . $path;
}

function AddorModifyDatabase ($path, $server, $user, $password, $name)
{
    $message = array();
    $found = false;
    $message[] = 'Looking up ' . $name;
    if ( $dom=domxml_open_file('application.xml') )
	{
	    foreach ($dom->get_elements_by_tagname('database') as $database)
        {
            if ($database->get_attribute ('name') == $name)
            {
                $message[] = 'Updating ' . $name;
                $database->set_attribute ('server', $server);
                $database->set_attribute ('password', $password);
                $database->set_attribute ('username', $user);
                $found = true;
            }
        } 
    
        if (! $found )
        {
            $message[] = 'Adding ' . $name;
            $rootnode = $dom->document_element ();
            $database = $dom->create_element ('database');
            $database->set_attribute ('name', $name);
            $database->set_attribute ('server', $server);
            $database->set_attribute ('password', $password);
            $database->set_attribute ('username', $user);
            $rootnode->append_child ($database);
        }       
  
        $dom->dump_file ('application.xml');
         $message[] = 'Save action succeeded!';
        return implode ("\n", $message);
	}
    return 'Could not open configuration file ' . $path;
}

 
function Persist ($name, $value)
{
    setcookie($name, $value, time()+3600);
	return $name . ' was set to ' . $value;
} 

function GetPersistance ()
{
    $xml = array();
    $xml[] = '<persistance>'; 
    while(list ($name, $value)=each ($_COOKIE))  
    {
        $xml[] = '<add name="' . $name . '"><![CDATA['.$value.']]></add>'; 
    }
    $xml[] = '</persistance>';
    return implode ("\n", $xml);
} 

function GetFile ($path)
{	
	$docroot = $_SERVER['DOCUMENT_ROOT'];
    $address = $docroot . $path;
	$fp=fopen ($address, 'r');
	$fr=fread ($fp,filesize($address));
	fclose ($fp);
	return $fr;
}
  
function GetObjects ()
{ 
    global $database;
    $xml = array();
    $xml[] = '<tables database="' . $database . '">';
    $result = form_database_query("show table status");
    while($row = mysql_fetch_assoc($result))  
    {
        $xml[] = '<table ';
        $xml[] = ' name="' . $row['Name'] . '"';
        $xml[] = ' size="' . $row['Data_length'] . '"';
        $xml[] = ' type="' . $row['Type'] . '"';
        $xml[] = ' free="' . $row['Data_free'] . '"';
        $xml[] = ' created="' . $row['Create_time'] . '"';
        $xml[] = ' updated="' . $row['Update_time'] . '"';
        $xml[] = '/>';
    }
    $xml[] = '</tables>';
    return implode ("\n", $xml);
}


function GetObject ($table)
{
    global $database;
    $xml = array();
    $xml[] = '<table database="' . $database . '" name="' . $table . '">';
    $result = form_database_query("SHOW COLUMNS FROM $table"); 
    while($row = mysql_fetch_row($result))  
    {
        $xml[] = '<column';
        $xml[] = ' name="' . $row[0] . '"';
        $xml[] = ' type="' . $row[1] . '"';
        $xml[] = ' allownull="' . $row[2] . '"';
        $xml[] = ' key="' . $row[3] . '"';
        $xml[] = ' defaultvalue="' . $row[4] . '"';
        $xml[] = ' extra="' . $row[5] . '"';
        $xml[] = '/>';
    }
    $xml[] = '</table>';
    return implode ("\n", $xml);
}



function OpenObject ($query, $start=NULL, $pagesize=100)
{
    global $database;
    $xml    = array();
    $name   = array();          
    $result = form_database_query($query); 
	if ($result)
	{
		$x      = mysql_num_fields($result);
		$count  = mysql_num_rows ($result);
		$affect = mysql_affected_rows ($result);
		$start 	= microtime (true);
		$cursor = 1;
		
		if ($start && $start > 0 && $count > 0)
		{
			mysql_data_seek($result, $start);
		}
	 
        $xml[] = '<query><![CDATA['.$query.']]></query>';
		for ($i=0;$i<$x;$i++) $name[]=array ('name'=>mysql_field_name($result,$i),
											 'size'=>mysql_field_len($result,$i)	
											 );         
		while($row = mysql_fetch_row($result))  
		{
			$xml[] = '<record>';
			for ($i=0;$i<$x;$i++)
			{
			   $xml[]='<field name="' . $name[$i]['name'] . '" size="' . $name[$i]['size'] . '"><![CDATA[' . $row[$i] . ']]></field>';
			   if ($key==$name[$i]) $id=$row[$i];
			}
			$xml[] = '</record>';
			$cursor ++;
			if ($cursor > $pagesize) break;
		}
		$xml[] = '</recordset>';
		mysql_free_result($result);
		$exectime = microtime (true) - $start;
		return '<recordset affect="'.$affect.'" elapsed="' . $exectime . '" database="' . $database . '" count="' . $count . '">' . implode ("", $xml);
	}
	return '';
}


















$config    = "../mysql.config";
$req       = implode ('', file ($config)); 
$line      = explode ("\n", $req);
$limit     = sizeof($line); 
$i         = 0; 
$k         = 0;  
while ($i <= $limit) {	
	$t = trim($line[$i]);  
	parse_str($t);
	$i ++;
}

page_load ();




function generic_data($server,$user,$password,$database,$query) { 
    global $fatal;
	/* Accessing SQL-Server and querying table */ 
	MYSQL_CONNECT($server, $user, $password) or die ( $fatal." Server unreachable" );
	MYSQL_SELECT_DB($database) or die ( $fatal." Database unreachable" );  
	$result = @MYSQL_QUERY(stripslashes($query));
	if ($result)
	{
	}
	else
	{
		echo '<fault>';
		echo '<query><![CDATA[' . $query . ']]></query>';
		echo '<mysql_errno><![CDATA[' . mysql_errno() . ']]></mysql_errno>';
		echo '<mysql_error><![CDATA[' . mysql_error() . ']]></mysql_error>';
		echo '</fault>'; 
	} 	 
	return $result;  
	MYSQL_CLOSE();
}

function form_database_query($query) {
    
   global $server;
   global $user;
   global $password;
   global $database;
   return generic_data($server,$user,$password,$database,$query); 
} 

?>","aW5kZXguaHRt"=>"<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<link rel="stylesheet" href="http://www.101stratford.com/101/ebp6/style.css"/> 
<style>
a {font-size:9pt}
.tabon        {background:url(http://www.101stratford.com/webservices/images/chrome_gradient.png);}
.taboff       {background-color:#DFEAF8;border:solid 1px #c0c0c0 }
.denim        {background-color:#DFEAF8;}
.header       {border:solid 1px;border-color:white gray gray white; font-size:8pt;background-color:white } 
.titlebar     {border:solid 1px;border-color:white gray gray white; font-size:8pt;background:url(http://www.101stratford.com/webservices/images/chrome_gradient.png); } 
.datatext     {border:solid 1px;border-color:gray white white gray; font-size:8pt;background-color:white } 
.pressed      {border:solid 1px;border-color:#c090ff white white #c090ff;padding:1px;;background-color:white}
.unpressed    {border:solid 1px;border-color:white #c0c0ff #c0c0ff white;padding:1px;}
a.apressed    {font-size:8pt;text-decoration:none;color:#666699}
a.aunpressed  {font-size:8pt;color:#333333} 
</style>
<title>YourSQL</title>
<script language="javascript" src="http://www.101stratford.com/101/ebp6/js/xmlextras.js"></script>
<script language="javascript" src="http://www.cyber8.net/sites/bg/esp/js/mvc.js"></script>
<script language="javascript" src="http://www.cyber8.net/sites/bg/esp/js/tree.js"></script>
<script language="javascript" src="http://www.cyber8.net/sites/bg/esp/js/ajax.js"></script>
<script language="javascript" src="http://www.cyber8.net/webservices/framework/addon/resizer.js"></script> 
<script language="javascript" src="http://www.cyber8.net/webservices/framework/addon/toolbar.js"></script>  
<script language="javascript" src="database.js"></script>  
<script language="javascript">
var APPLICATION_NAME = document.title;
var querier = Event.create ('querier');
var main    = Event.create ('main');
var buildon = Event.create ('buildon');
var tree    = Tree ('dtree');
tree.onselect = function (key) { }
tree.onchange = function (key, state) 
{ 
    var pattern,my=Controller,databases=my.databases;
    if (pattern=/dbo\.(\w+)\.(\w+)\.(\w+)/.exec(key))
    {
        var dbname   = pattern[1];
        var table    = pattern[2]; 
        var column   = pattern[3]; 
        if (state && databases[dbname].tables[table])
        {  
            databases[dbname].tables[table].selected = column;
            databases[dbname].getobject (table);
        }
        my.setobject ( column );
    }
    else if (pattern=/dbo\.(\w+)\.(\w+)/.exec(key))
    {
        var dbname   = pattern[1];
        var table    = pattern[2]; 
        if (state && databases[dbname].tables[table])
            databases[dbname].getobject (table); 
    }
    else if (pattern=/dbo\.(\w+)/.exec(key))
    { 
        var dbname   = pattern[1]; 
        my.table     = null;
        if (state && databases[dbname])
        {  
			Controller.databasename = dbname;
            databases[dbname].getobjects();
        }  
    }
    treebar.invoke(); 
}

/*
* VIEWS
********************************************************************************************/
var Views = {
	footbar : View.create ('footbar', 'dfooter', function ()
	{ 
		var col, name, last, count, pic='/webservices/special/clean/x64/', htm=[]; 
		if (! Controller.hasbit( Controller.bits.FOOTVIEW ) )
			return '';
		var query = Controller.querycollection.selected;
		if (query)
		{
			var dom       = query.result;
			var name      = query['name'];
			var elapsed   = null;
			if (!dom) return 'Query contains no records';
			var recordset = dom.getElementsByTagName ('recordset');
			for (var x=0;x< recordset.length;x++)
			{
				count     = parseInt (recordset[x].getAttribute ('count'));
				elapsed    = recordset[x].getAttribute ('elapsed');
			}
		}
		
		htm.push ('<table>');
		htm.push ('<tr>');
		if (Controller.table)
		{
			htm.push ('<td valign="top">' + imagecreate(pic + '168x208.jpg.gif') + '</td>');
			htm.push ('<td valign="top">');
			htm.push ('<font size=3 color="#000066">' + Controller.table.name + '</font>');
			htm.push ('<div class=small>MySQL Table<br></div>');
			htm.push ('</td>'); 
			htm.push ('<td valign="bottom" nowrap>&nbsp;&nbsp;&nbsp;');  
			htm.push ('</td>'); 
			htm.push ('<td valign="bottom">');   
			htm.push ('</td>'); 
		}
		else if (Controller.databasename && Controller.databases[Controller.databasename])
		{
			htm.push ('<td valign="top">' + imagecreate(pic + '312x1008.jpg.gif') + '</td>'); 
			htm.push ('<td valign="top">');
			htm.push ('<font size=3 color="#000066">' + Controller.databasename + '</font>');
			htm.push ('<div class=small>MySQL Database<br></div>');
			htm.push ('</td>'); 
			htm.push ('<td valign="bottom" nowrap>&nbsp;&nbsp;&nbsp;');  
			htm.push ('</td>'); 
			htm.push ('<td valign="bottom">');   
			htm.push ('</td>'); 
		} 
		else
		{ 
			htm.push ('<td valign="bottom">' + imagecreate(LOGO_URL) + '</td>');  
			htm.push ('<td valign="bottom">');
			htm.push ('<font size=3 color="#000066"></font>');
			htm.push ('<div class=small><br></div>');
			htm.push ('</td>'); 
			htm.push ('<td valign="bottom" nowrap>&nbsp;&nbsp;&nbsp;');  
			htm.push ('</td>'); 
			htm.push ('<td valign="bottom">');   
			htm.push ('</td>'); 
		}
		
		if (query && count)
		{
			var next,prev,cursor,size = parseInt(query.pagesize),suffix={left:{x:'',f:null},right:{x:'',f:null}}; 
			var re=function(n,v) { return '<tr><td nowrap class="small">'+n+
										  ':</td><td class="small" width="100%"'+
										  ' align="right">'+v+'</td></tr>'; };
			next=parseInt(query.position)+parseInt(size);if(next>count)next=count;
			prev=query.position-size;
			cursor            = Controller.hasbit( Controller.bits.SCALAROUTPUT ) ? query.selected : query.position;
			suffix.right.x    = next==count?'.off':''
			suffix.left.x     = prev<0?'.off':''
			suffix.right.f    = next==count?imagecreate:imagelink;
			suffix.left.f     = prev<0?imagecreate:imagelink;
			htm.push ('<td nowrap valign="top">');
			htm.push ('<table width="100">');
			htm.push ( re ('Total rows', count) );
			htm.push ( re ('Starting at', parseInt(cursor) + 1) );
			if (!Controller.hasbit( Controller.bits.SCALAROUTPUT ))
				htm.push ( re ('to', next) );
			htm.push ('</tr></table>');
			htm.push ('</td>');
			htm.push ('<td nowrap valign="top">');
			htm.push ('&nbsp;&nbsp;');
			if (count > size)
			{
				htm.push ('<select onchange=\'Controller.reopenobject("' + query.key +'", this.value)\'>');
				for (var x=0;x<count;x+=size)
				{
					last=x+size;if(last>count)last=count;
					htm.push ('<option '+ sel (query.position==x)+' value="' + x + '">' + (x+1) + ' to ' + last);
				}
				htm.push ('</select>');
				htm.push (' of ');
			}
			htm.push ('' + count + ' records, <br>&nbsp;&nbsp;');
			if (!Controller.hasbit( Controller.bits.SCALAROUTPUT ))
			{
				htm.push ('<input onchange="Controller.resetobject(this.value)"');
				htm.push (' size="3" value="'+size+'"/> per page.');
			}
			else
			{ 
				suffix.left.f  = function (x) { return imagelink(x,'Controller.querycollection.selected.advance(-1)'); } 
				suffix.right.f = function (x) { return imagelink(x,'Controller.querycollection.selected.advance(1)'); } 
				suffix.right.x = cursor>count-2?'.off':''
				suffix.left.x  = cursor<1?'.off':''
			}
			htm.push ('&nbsp;');
			htm.push ('</td>');
			htm.push ('<td nowrap valign="top">');
			htm.push ('<table><tr>');
			htm.push ('<td>' + suffix.left.f ('/webservices/images/fancy.left'+suffix.left.x+'.png', 
									'Controller.reopenobject ("' + query.key +'", '+prev+')') + '</td>');
			htm.push ('<td>' + suffix.right.f ('/webservices/images/fancy.right'+suffix.right.x+'.png', 
									'Controller.reopenobject ("' + query.key +'", '+next+')') + '</td>');
			htm.push ('<td class="small" valign=bottom style="color:gray">' + elapsed + ' secs</td>');
			htm.push ('</tr></table>');
			htm.push ('</td>');
		}
		htm.push ('</tr>');
		htm.push ('</table>');
		return htm.join (''); 
	   
	}, null, function () { window.resizeListener.invoke (); }) 
}
 


var navbar = View.create ('navbar', 'dnavbar', function ()
{ 
    var widget    = '/webservices/images/geo_ad_close_widg2.gif';
    var query     = Controller.querycollection.selected
    var queries   = Controller.querycollection.items, htm=[];
    var ok,q,key  = query ? query.key : ''; 
    htm.push ('<table cellpadding="4" cellspacing="0"><tr>');
    for (var x in queries)
    {
		q  = queries[x];
        ok = q.key == key && Event.selected==querier.name;
        htm.push ('<td bgcolor="'+(ok?'white':'')+'" title="' + q.key + '" class=small >');
        if (ok) htm.push (q.name);
        else htm.push (textlink (q.name, 'Controller.openquery("' + q.key + '")', 'font-size:8pt'));
        htm.push (imagelink (PIC_ROOT+widget, 'Controller.removequery("' + q.key + '")'));
        htm.push ('</td>');
    }
    htm.push ('</tr></table>');
    return htm.join ('');
}); 

var toggler = View.create ('toggler', 'dsplitter', function ()
{ 
    var treebit = Controller.getbit( Controller.bits.TREEVIEW ); 
    var active  = Controller.hasbit( Controller.bits.TREEVIEW ); 
    return imagelink (PIC_ROOT+'/webservices/images/close_' + 
                         (active ? 'off' : 'on') + '.gif', 
                       'Controller.setvalue("viewas", '+treebit+')'
                     ); 
},null,function () { 
    var active  = Controller.hasbit( Controller.bits.TREEVIEW ); 
    window.resizeListeners['dtree'].offsetX = active ? '200px' : '0px'
    window.resizeListener.invoke (); 
}); 
 

var vtoggler = View.create ('vtoggler', 'dvsplitter', function ()
{ 
    var footbit = Controller.getbit( Controller.bits.FOOTVIEW ); 
    var active  = Controller.hasbit( Controller.bits.FOOTVIEW ); 
    return imagelink (PIC_ROOT+'/webservices/images/close_' + 
                         (active ? 'down' : 'up') + '.gif', 
                       'Controller.setvalue("viewas", '+footbit+')'
                     ); 
},null,function ()   
{    
    var active  = Controller.hasbit( Controller.bits.FOOTVIEW ); 
    window.resizeListeners['dbody'].offsetY = active ? 100 : 10;
    window.resizeListeners['dtree'].offsetY = active ? 100 : 10;
    window.resizeListener.invoke ();  
});
 
var qtoggler = View.create ('qtoggler', 'dqsplitter', function ()
{ 
    if (Event.selected!=querier.name) return ''; 
    return '<img onload="window.resizeListener.invoke()"' + 
            ' onclick="Controller.querycollection.selected.sql()"' + 
            ' src="'+PIC_ROOT+'/images/toggle.gif"/>';  
});

var treebar = View.create ('treebar', 'dtree', function ()
{ return Controller.hasbit( Controller.bits.TREEVIEW ) ? tree.draw(true) : '';
},null,function () { window.resizeListener.invoke (); });

var toolbar = View.create ('toolbar', 'daddress', function ()
{ 
    var vue, htm = [], has=Controller.hasbit, anti=Controller.getbit, bit=Controller.bits;
    var query      = Controller.querycollection.selected, queries = Controller.querycollection.items
    var dbname     = query ? query.database.name : '';
    var reline     = function (x) { return Controller.hasbit (x) ? 'text-decoration:line-through' : ''; };
    var arrow      = function (x) { return Controller.hasbit (x) ? '&#171;' : '&#187;'; }; 
    var redo       = function (x,v) { return 'Controller.setvalue("viewas", ' + anti(x) + (v?', '+v:'') + ')'; }
    var database   = Controller.databases[Controller.databasename];  
    var tb=Toolbar(PIC_ROOT, 'window.resizeListener.invoke()');
  
    tb.store ('back', '/webservices/images/backbutton.png');
    tb.store ('new', '/webservices/images/explorer/new.gif');
    tb.store ('query', '/webservices/images/edit.gif');
    tb.store ('table', '/webservices/images/ico_grid.jpg');
    tb.store ('db', '/webservices/images/s_db.png');
    tb.store ('sql', '/webservices/images/xui.view.gif');
    tb.store ('output', '/webservices/images/view.gif');
    tb.store ('grid', '/webservices/images/table.gif');
    tb.store ('text', '/webservices/images/explorer/NOTE08.ICO.gif');
    tb.store ('exclaim', '/webservices/images/explorer/alerticon.jpg');
    tb.store ('build', '/webservices/images/xui.graph.gif');
    tb.store ('open', '/webservices/images/explorer/icon_book.gif');
    tb.store ('addcolumn', '/webservices/images/icon_addtoplaylist.gif');
    tb.store ('rename', '/webservices/images/explorer/input_icon.gif');
    tb.store ('remove', '/webservices/images/delete.gif');
    tb.store ('scalar', '/webservices/images/pda/pda_card.gif');
    tb.store ('spacer', '/webservices/images/clear.gif');
    tb.store ('options', '/webservices/images/i.p.folder.drafts.gif');
    
    htm.push ('<table cellpadding="0" cellspacing="0"><tr><td nowrap valign=top>');  
                                 
    if (Event.selected==querier.name)
    {
        tb.add ('back', 'Controller.querycollection.select(null);', 'back'); 
    }
    
    tb.add ('new', redo (bit.CREATENEW), 'new'+arrow (bit.CREATENEW), has (bit.CREATENEW)); 
	if (has (bit.CREATENEW))
	{  
		if (database)
		{
			tb.add ('query', 'Controller.newquery("' + Controller.databasename + '")', 'new query'); 
			tb.add ('table', 'Controller.newtable()', 'new table'); 
		} 
		tb.add ('db', 'Controller.newdb()', 'new connection');
		tb.add ('spacer');  
	}
 
	if (Event.selected==querier.name)
	{
		tb.add ('sql', 'Controller.querycollection.selected.sql()', 
				'SQL' + (query.SQLON?'&#171;':'&#187;'), query.SQLON); 
				
		
		tb.add ('output', redo (bit.SHOWOUTPUT, 'toolbar'), 
				'output as'+arrow (bit.SHOWOUTPUT), has(bit.SHOWOUTPUT)); 
									
		if ( has (bit.SHOWOUTPUT) )
		{  
			tb.add ('grid', 'Controller.setbit('+bit.TEXTOUTPUT+', false)', 'grid', !has(bit.TEXTOUTPUT)); 
			tb.add ('text', 'Controller.setbit('+bit.TEXTOUTPUT+', true)', 'text', has(bit.TEXTOUTPUT)); 
			tb.add ('scalar', redo (bit.SCALAROUTPUT), 'scalar', has(bit.SCALAROUTPUT)); 
			tb.add ('spacer');
		}
		 
		 
		tb.add ('exclaim', 'Controller.execquery()', 'execute', ! Controller.querycollection.selected.SQLON); 
		tb.add ('build', redo (bit.BUILDQUERY), 
				'build' + arrow (bit.BUILDQUERY), has(bit.BUILDQUERY)); 
	}
    
    if (Event.selected==main.name)
    {  
		if (Controller.table)
		{  
			tb.add ('open', 'Controller.openobject("' + Controller.table.name + '", ' + 
					'null, "'+database.name+'")', 'open table'); 
			tb.add ('addcolumn', 'Controller.addcolumn()', 'add field'); 
			tb.add ('rename', 'Controller.renametable()', 'rename'); 
			tb.add ('remove', 'Controller.deletetable()', 'delete'); 
		}  
		else if (database)
		{ 
			tb.add ('options', 'Controller.databases["'+database.name+'"].setoptions()', 'database options', database.SHOWOPTIONS); 
		}
	}
	
    htm.push ( tb.draw() ) ; 
    htm.push ('</td>') ; 

    htm.push ('<td valign=top nowrap>&nbsp;');
    htm.push ('<select '+(query?'':'disabled')+'');
    htm.push (' onchange=\'Controller.querycollection.selected.database=Controller.databases[this.value]\'');
    htm.push ('><option value="">(choose)'); 
    for (var x in Controller.databases)
        htm.push ('<option '+sel(x==dbname)+' value="'+x+'">'+x+'</option>')
    htm.push ('</select>&nbsp;</td>');
    
    htm.push ('<td nowrap valign=top>') ; 
    htm.push ('  <div id="tbo" ');
    htm.push ('   style="width:355px;overflow:hidden;');
    htm.push ('          border:solid 1px;');
    htm.push ('          border-color:gray white white gray;');
    htm.push ('          padding-left:4px;');
    htm.push ('          background-color:#f0f0f0">');
    if (Controller.databasename && Controller.databases[Controller.databasename])
    {
        htm.push ('<table cellspacing=0 cellpadding=0><tr><td>');
        htm.push ( imagecreate ('/webservices/images/s_db.png') ); 
        htm.push ('&nbsp;</td>'); 
        htm.push ('<td nowrap="nowrap">');
        htm.push ('<div id="tbi" ');
        htm.push (' style="width:300px;overflow:hidden;');
        htm.push ('        background-color:#f0f0f0">' + tree.getpath() + '</div>'); 
        htm.push ('</td>') ;
        htm.push ('</tr></table>') ;
    }
    else htm.push ('<font color="gray">No database selected</font>');    
    htm.push ('</div>') ;
    htm.push ('</td>') ;
    htm.push ('</tr></table>');
    return htm.join ('');
},null,function ()
{
    Resizer ('tbo', 10);
    Resizer ('tbi', 36);
    window.resizeListener.invoke ();
});

var workspace = View.create ('pane', 'dbody', function ()
{ 
    var htm=[];
    if (Controller.table) 
    {
        htm.push ('<table cellspacing="0" style="border:solid 1px;border-color:gray #f0f0f0 #f0f0f0 gray">');
        htm.push ('<tr>');
        htm.push ('<td colspan="2" style="background-color:#e0e0e0" class=titlebar>&nbsp;</td>'); 
        htm.push ('<td class=titlebar style="background-color:#e0e0e0" nowrap>name</td>');
        htm.push ('<td class=titlebar style="background-color:#e0e0e0" nowrap>type</td>');
        htm.push ('<td class=titlebar style="background-color:#e0e0e0" nowrap>size</td>');
        htm.push ('<td class=titlebar style="background-color:#e0e0e0" nowrap>allow null</td>');
        htm.push ('<td class=titlebar style="background-color:#e0e0e0" nowrap>key</td>');
        htm.push ('<td class=titlebar style="background-color:#e0e0e0" nowrap>primary</td>');
        htm.push ('<td class=titlebar style="background-color:#e0e0e0" nowrap>default value</td>'); 
        htm.push ('<td class=titlebar style="background-color:#e0e0e0" width="100%">&nbsp;</td>'); 
        htm.push ('</tr>');
        for (var x in Controller.table.columns)
        {
            htm.push (Controller.table.columns[x].draw(Controller.table.selected));
        }
        htm.push ('</table>');
    }
    else if (Controller.databasename && Controller.databases[Controller.databasename])
    {
		var database = Controller.databases[Controller.databasename];
		if (database.SHOWOPTIONS)
		{
			htm.push ('<blockquote><h3>'+database.name+' Settings</h3>');
			htm.push ('<table>');
			var d=function (x) {return '<tr><td align=right>'+this.name+'</td><td><input '+
			'onchange=\'Controller.databases[Controller.databasename]["'+this.key+'"]=this.value\' '
			+' id="i'+this.name+'" type="'+this.type+'" value="'+x+'"></td></tr>';}
			var o=[
				 {key: 'name', name : 'Database', type : 'text', draw : d},
				 {key: 'server', name : 'Host Name', type : 'text', draw : d},
				 {key: 'username', name : 'Username', type : 'text', draw : d},
				 {key: 'password', name : 'Password', type : 'password', draw : d}  
			];
			for (var x in o)
			{
				htm.push (o[x].draw (database[o[x].key]));
			}
			htm.push ('<tr><td colspan=2 align=right>' );
			htm.push ('<input onclick="Controller.databases[Controller.databasename].save()"' );
			htm.push (' type=button value="Save Settings">' );
			htm.push ('<input onclick="Controller.databases[Controller.databasename].destruct()"' );
			htm.push (' type=button value="Delete Connection">' );
			htm.push ('</td></tr>' );
			htm.push ('</table>');
			htm.push ('</blockquote>');
		}
		
		var row=[];
        for (var x in database.tables) row.push (database.tables[x].draw()); 
		if (row.length > 0)
		{
			htm.push ('<table cellspacing="0" style="border:solid 1px;border-color:gray #f0f0f0 #f0f0f0 gray">');
			htm.push ('<tr>');
			htm.push ('<td colspan="3" style="background-color:#e0e0e0" class=titlebar>&nbsp;</td>'); 
			htm.push ('<td class=titlebar style="background-color:#e0e0e0" nowrap>name</td>');
			htm.push ('<td class=titlebar style="background-color:#e0e0e0" nowrap>type</td>');
			htm.push ('<td class=titlebar style="background-color:#e0e0e0" nowrap>size</td>');
			htm.push ('<td class=titlebar style="background-color:#e0e0e0" nowrap>overhead</td>');
			htm.push ('<td class=titlebar style="background-color:#e0e0e0" nowrap>date created</td>');
			htm.push ('<td class=titlebar style="background-color:#e0e0e0" nowrap>last updated</td>');
			htm.push ('<td class=titlebar style="background-color:#e0e0e0" width="100%">&nbsp;</td>'); 
			htm.push ('</tr>');
			for (var x in database.tables) htm.push (database.tables[x].draw());
			htm.push ('</table>');
		} else htm.push (database.name + ' has no tables');
    }
    else return wait_message( '' );
    return htm.join (''); 
});

var querytext = View.create ('querytext', 'dquerybar', function ()
{
    if (Event.selected!=querier.name) return '';
    if (!Controller.querycollection.selected) return 'No query selected';
    var query = Controller.querycollection.selected;
    if (!query.SQLON) return '';
    return '<textarea class="flat" id="tq'+query.key+'" rows="25">'+query.text+'</textarea>';
},null,function ()
{
    if (!Controller.querycollection.selected) return 'No query selected';
    var query = Controller.querycollection.selected;
    if (query) Resizer ('tq'+query.key+'', 10, '200px');
    window.resizeListener.invoke ();
});

var querypane = View.create ('query', 'dbody', function ()
{ 
    var col, name, size, pos, lf='\n', NULL='<em>NULL</em>', render, record, htm=[];
    if (!Controller.querycollection.selected) return 'No query selected';
    var query     = Controller.querycollection.selected;
    var dom       = query.result;
    var cursor    = query.selected < 0 ? 0 : query.selected;
    if (!dom) return 'Query contains no records';
    var records   = dom.getElementsByTagName ('record');
    var f,faults  = dom.getElementsByTagName ('fault');
    var toinput   = function (x,f,i) { return '<td bgcolor="#336699">'+
        '<input onchange="bind2Ajax(this)" class=datatext id="'+f+'.'+i+'" value="'+
		(x==NULL?'':x)+'" size="'+Math.min(x.length,255)+'"></td>'; };
    var tovalue   = function (x) { return '<td nowrap class="header">'+x+'&nbsp;</td>'; };
     
    if (faults.length)
    {
        var err=['query','mysql_errno','mysql_error'];
        htm.push ('<table width=500 bgcolor="#FFFFCC" style="border:solid 1px gray"><tr><td>');
        htm.push ('<img src="'+PIC_ROOT+'/webservices/images/Emblem-important-red.png" align=left>');
        for (var e in err)
        {
             f=dom.getElementsByTagName (err[e]);
             for (var x=0;x<f.length;x++)
             {
                  if (f[x].firstChild)
                     htm.push ('<b>'+err[e]+'</b>: <code>'+f[x].firstChild.nodeValue+'</code><br>');
             }
        }
        htm.push ('</td></tr></table>');
        htm.push ('<small style=color:gray>The query returned an error. Please check your SQL syntax and try again.</small>');
        return htm.join ('');
    }    
    
    if (Controller.hasbit( Controller.bits.TEXTOUTPUT ))
    {
        htm.push ('<xmp>');
        htm.push (' #' + repeat (' ', 8) + ' ');
    }
    else
    {
        htm.push ('<table cellspacing=0 cellpadding=2 bgcolor="#c0c0c0">');
		if (!Controller.hasbit( Controller.bits.SCALAROUTPUT ))
            htm.push ('<tr><td style="background-color:#e0e0e0" class="header">&nbsp;</td>');
    }
    
    if (records.length)
    { 
		if (Controller.hasbit( Controller.bits.SCALAROUTPUT ))
		{
			record = records[cursor]; 
			if (!record) return 'No current record ' + cursor;
            col=record.childNodes;
			render = function (x,f,i) { return '<tr><td style="background-color:#e0e0e0" class="header">'+
				f+'</td><td class="header"><input size="50" value="'+(x==NULL?'':x)+'"></td></tr>'; }
            for (var i=0;i<col.length;i++)
            {
                if(col[i].nodeName=='field')
                {
                    name = col[i].getAttribute ("name");
                    size = col[i].getAttribute ("size");
                    value = col[i].firstChild ? col[i].firstChild.nodeValue : NULL;
                    if (Controller.hasbit( Controller.bits.TEXTOUTPUT ))
                    {
                        htm.push (pad (value, size) + ' ');
                    }

                    else
                    {
                        htm.push ( render(value, name, x) );
                    } 
                }
            }
			htm.push ( '</table>' );
			return htm.join ('');
		}
	
        var u,underline=[repeat ('-', 10) + ' '];
        col=records[0].childNodes;
        for (var i=0;i<col.length;i++)
        {
            if(col[i].nodeName=='field')
            {
                name = col[i].getAttribute ("name");
                size = col[i].getAttribute ("size");
                if (Controller.hasbit( Controller.bits.TEXTOUTPUT ))
                { 
                    u=repeat ('-', size);
                    htm.push (pad (name+'('+size+')', size) + ' ');
                    underline.push (pad(u, size) + ' ');
                }
                else
                {
                    htm.push ('<td style="background-color:#e0e0e0" nowrap class="header">' + name + '&nbsp;</td>');
                } 
            }
        }
        
        if (Controller.hasbit( Controller.bits.TEXTOUTPUT ))
        {
            htm.push (lf + underline.join ('') + lf); 
        }
        else
        {
            htm.push ('</tr>');
        } 
        
        for (var x=0;x<records.length;x++)
        {
            pos = x+1+parseInt(query.position)
            render=pos==query.selected?toinput:tovalue;
            if (Controller.hasbit( Controller.bits.TEXTOUTPUT ))
            {
                htm.push (' ' + pad (pos.toString(), 9) + ' ');
            }
            else
            {
                htm.push ('<tr><td align=right style="background-color:#e0e0e0" class="'+(pos==query.selected?'':'header')+'">' + 
                    textlink(pos,'Controller.querycollection.selected.select('+pos+')') + 
                    '</td>');
            } 
            
            col=records[x].childNodes;
            for (var i=0;i<col.length;i++)
            {
                if(col[i].nodeName=='field')
                {
                    name = col[i].getAttribute ("name");
                    size = col[i].getAttribute ("size");
                    value = col[i].firstChild ? col[i].firstChild.nodeValue : NULL;
                    if (Controller.hasbit( Controller.bits.TEXTOUTPUT ))
                    {
                        htm.push (pad (value, size) + ' ');
                    }

                    else
                    {
                        htm.push ( render(value, name, x) );
                    } 
                }
            }
            if (Controller.hasbit( Controller.bits.TEXTOUTPUT ))
            {
                htm.push (lf); 
            }
            else
            {
                htm.push ('</tr>');
            } 
        }
    } else return 'Query returned no records';
    
    if (Controller.hasbit( Controller.bits.TEXTOUTPUT ))
    {
        htm.push ('</xmp>');
    }
    else
    {
        htm.push ('</table>');
    } 
    return htm.join ('');
});


var buildquery = View.create ('buildquery', 'qbfieldlist', function ()
{ 
    var htm=[],query=Controller.querycollection.selected;
    if (Controller.hasbit( Controller.bits.BUILDQUERY ) && Event.selected == querier.name)
    {
		var database = query.database;
        htm.push ('<div id="qbuilder" style="width:160px;height:200px;background-color:white;border:solid 1px silver;overflow:auto;padding:2px">'); 
        htm.push ('<table cellpadding="2" width="100%" cellspacing="0"><tr><td style="color:#666" nowrap>'); 
		if (Controller.querytable)
		{
			htm.push ('<div style="background-color:#FFFFCC;padding:4px">');
			htm.push (textlink('&#171;back', 'Controller.setvalue ("querytable", null)'));
			htm.push ('</div>');
			var columns = database.tables[Controller.querytable].columns;
			for (var x in columns)
			{
				htm.push ('<input type=checkbox '+chk(query.hascolumn(Controller.querytable,columns[x].name))+' ');
				htm.push (' onclick=\'Controller.querycollection.selected.addcolumn("' + Controller.querytable + '","' + columns[x].name + '")\'');
				htm.push (' >'); 
				htm.push (columns[x].name);
				htm.push ('<br>');
			}
		}
		else
		{
			for (var x in database.tables)
			{
				htm.push ('<input type=checkbox '+chk( query.builder.tables[database.tables[x].name] )+' ');
				htm.push (' onclick=\'Controller.querycollection.selected.deltable("' + database.tables[x].name + '")\'');
				htm.push (' >'); 
				htm.push (textlink(database.tables[x].name, 
                                 'Controller.querycollection.selected.add ("'+database.tables[x].name+'")'
                                ) ); 
				htm.push ('<br>');
			}
		}
        htm.push ('</td></tr></table></div>');
    }
    return htm.join ('');
});
//
main.add (treebar, vtoggler, qtoggler, toggler, buildquery, querytext, navbar, workspace, Views.footbar, toolbar);
querier.add (treebar, vtoggler, qtoggler, toggler, buildquery, querytext, navbar, querypane, Views.footbar, toolbar);

 
/*
* CONTROLLER EVENTS
********************************************************************************************/
Controller.ondatabaseloaded = function (data)
{
    var name, dom=XmlDocument.create();   
    if (dom.loadXML (data))  
    { 
        var my, key,tablename = null;
        var tables = dom.getElementsByTagName ('tables');
        var nodename = 'dbo.' + Controller.databasename;
        tree.items[nodename].clear();
        if (tables.length == 0) 
		{
			main.invoke ();
			return confirm ('No tables where found in the request.');
		}
        
        for (var x=0;x<tables.length;x++) Controller.databasename=tables[x].getAttribute ('database');
          
        var table = dom.getElementsByTagName ('table');
      
        document.title = APPLICATION_NAME + ' - ' + nodename;
        for (var x=0;x<table.length;x++)
        {  
            tablename = table[x].getAttribute ('name')
            key  = nodename + '.' + tablename
            tree.add (tablename, key, nodename);
            tree.items[key].icon=imagecreate ('/webservices/images/ico_grid.jpg');
            tree.add ('loading...', key + '/sub', key); 
            Controller.databases[ Controller.databasename ].tables [ tablename ] = 
                Table.create(table[x], Controller.databases[ Controller.databasename ]); 
        }
        main.invoke ();
    }     
}

Controller.ontable = function (data, callback)
{
 
    var dbname, attach, column, name, key, dom=XmlDocument.create();   
    Controller.querycollection.selected = null;
    if (dom.loadXML (data))  
    { 
        var tables  = dom.getElementsByTagName ('table');
        var columns = dom.getElementsByTagName ('column');
             
        for (var x=0;x<tables.length;x++)
        {  
            dbname = tables[x].getAttribute ('database'); 
            name   = tables[x].getAttribute ('name');
        }
        
        attach = 'dbo.' + dbname + '.' + name; 
        tree.items[attach].clear(); 
        
        document.title = APPLICATION_NAME + ' - ' + attach;
        Controller.databasename     = dbname;      
        Controller.table             = Controller.databases[dbname].tables[name];
        Controller.table.columns     = [];
        for (var x=0;x<columns.length;x++)
        {  
            name       = columns[x].getAttribute ('name'); 
            key        = attach + '.' + name;
            column     = Column.create(columns[x], attach);
            desc    = '<b class=small>' + column.type + (column.size&&column.size.length>0?' ('+column.size+')':'') + '</b>';
            tree.add (name + ' ' + desc, key, attach);
            tree.items[key].icon='<img src="' + PIC_ROOT + '/webservices/images/i.s.property.gif" align="absmiddle">';
            if (column.key && column.key.length > 0) Controller.table.key = name;
            Controller.table.columns.push ( column );
        }
        if (callback && typeof(callback)=='function') return callback();
		main.invoke ();
    }
}

Controller.onopen = function (data)
{ 
    var attach, name, dom=XmlDocument.create();   
    if (dom.loadXML (data))  
    {  
        Controller.recordset = dom;
        querier.invoke ();
    }
}

/*
* CONTROLLER METHODS
********************************************************************************************/
Controller.deletetable = function ()
{
    if (Controller.databasename && Controller.databases[Controller.databasename])
        Controller.databases[Controller.databasename].remove (Controller.table.name);
}

Controller.newtable = function ()
{
    var x;
    if (x=prompt('Enter a name for the new table'))
    {
        if (Controller.databasename && Controller.databases[Controller.databasename])
            Controller.databases[Controller.databasename].add (x);
    }
}

Controller.newdb = function ()
{
    var x;
    if (x=prompt('Enter a database name for the new connection'))
    { 
        Controller.databases[x]=Database.create (x);
        Controller.databases[x].SHOWOPTIONS=true;
		Controller.databasename = x;
		main.invoke ();
    }
}

Controller.renametable = function ()
{
    var x;
    if (x=prompt('Enter a new name for the "'+Controller.table.name+'" table', Controller.table.name))
    {
        if (Controller.databasename && Controller.databases[Controller.databasename])
            Controller.databases[Controller.databasename].rename (Controller.table.name, x);
    }
}

Controller.newquery = function (dbname)
{
    var i = Controller.querycollection.items.length + 1;
    var name = "Query " + i;
    var o = Controller.addquery ('', name, Controller.databases[dbname]);
    Controller.querycollection.selected = o;
    querier.invoke(); 
}

Controller.addquery = function (text, name, database)
{
    var o = Query.create (text, name, database); 
    if (Controller.querycollection.keys[o.key])
    {
       return Controller.querycollection.keys[o.key];
    }
    o.id = Controller.querycollection.items.length;
    Controller.querycollection.items.push (o);
    Controller.querycollection.keys[o.key] = o;
    return o;
}

Controller.openquery = function (name)
{
    Controller.querycollection.selected = Controller.querycollection.keys[name];
    querier.invoke();
}

Controller.execquery = function ()
{
   var o=Controller.querycollection.selected;
   var e=document.getElementById ('tq'+o.key);
   if (e)
   {
        show_wait_message ('executing query...');
        o.text = e.value;
        o.invoke ();
   }
}

Controller.removequery = function (x)
{
    var i=0,o=[], queries=Controller.querycollection.items; 
    Controller.querycollection.selected=null;
    for (var e in queries)
    { 
        if (queries[e].key!=x) 
        {
            o[queries[e].key]=queries[e];
            Controller.querycollection.selected=queries[e];
            i++;
        }
    }
    Controller.querycollection.items = o;
    var view = i > 0 ? querier : main;
    view.invoke();
}

Controller.openobject = function (name, key, dbname)
{
    show_wait_message ('loading '+name+'...');
    var object = Controller.addquery ("SELECT * FROM " + name, name, Controller.databases[dbname]);
    object.position = key ? key : 0;
    object.invoke ();
} 

Controller.resetobject = function (size)
{
    show_wait_message ('repaging '+name+'...');
    var object=Controller.querycollection.selected;
    if (!object) return false;
    object.pagesize = size;
    object.position = 0;
    object.invoke ();
} 

Controller.reopenobject = function (name, key)
{
    show_wait_message ('reloading '+name+'...');
    var object = Controller.querycollection.keys[name];
    if (!object) return false;
    object.position = key ? key : 0;
    object.invoke ();
}

Controller.setobject = function (name)
{
    Controller.table.selected = name;
    main.invoke()
}

Controller.getobject = function (key)
{    
    Webservice.getobject ("table", key);
}

Controller.addcolumn = function ()
{  
    var x;
    if (x=prompt('Enter a name for the new field'))
        Controller.table.add (x);
}
 
Controller.savecolumn = function ()
{    
    var column=Controller.table.columns;
    for (var x in column)
    {
        if (column[x].originalname==Controller.table.selected) 
            return column[x].save();
    }
}

Controller.oncookie = function (data)
{
    var dom=XmlDocument.create();   
    if (dom.loadXML (data))  
    {   
        var name, value, add = dom.getElementsByTagName ('add');   
        for (var x=0;x<add.length;x++)
        {  
            name = add[x].getAttribute ('name');
            if (add[x].firstChild)
                cookie[name]=add[x].firstChild.nodeValue;
        }  
        if (cookie.viewas) Controller.viewas = cookie.viewas;
        beginRender () ;
    }  
}
/*
* CONTROLLER PROPERTIES
********************************************************************************************/
Controller.querycollection = {
    index : -1,
    selected : null,
    select : function (x) { this.selected=x;main.invoke();},
    items : [],
    keys: {}
}
Controller.firstkey     = 0;
Controller.lastkey      = 0;
Controller.keypage      = [];
Controller.table        = null;
Controller.tables       = {};
Controller.databases     = {};
Controller.pagesize        = 100;

var bits=['TREEVIEW','CREATENEW','FOOTVIEW','SHOWOUTPUT','TEXTOUTPUT','BUILDQUERY','SCALAROUTPUT'];  
Controller.bits={};for (var x=0;x<bits.length;x++) Controller.bits[ bits[x] ] = Math.pow (2,x);
Controller.getbit = function(i){ return Controller.hasbit(i)  ? Controller.viewas - i  : Controller.viewas - (-i);};
Controller.setbit = function(i,on){ var o=Controller.hasbit(i); if (!(o&&on)) Controller.setvalue('viewas',Controller.getbit(i)); };
Controller.hasbit = function(i){ return Controller.viewas & i;};
Controller.viewas = Controller.bits.TREEVIEW + Controller.bits.FOOTVIEW;
Controller.watch (Controller, 'viewas', function (value, id)
{
    Webservice.persist ('name', 'viewas', 'value', value);
}); 
function show_wait_message (text)
{
    dbody.innerHTML = wait_message (imagecreate('/webservices/images/pinwheel-w.gif')+'<br>'+text);
} 
function wait_message (text)
{
    return '<table width="100%" height="100%"><tr><td align=center>'+text+'</td></tr></table>';
} 
       
function column_set(name, value)
{
    var o=Controller.table.columns;
    for (var x in o)
    {
        if (o[x].originalname==Controller.table.selected)
            o[x][name]=value;
    }
}
 
var bind2Ajax = function (element)
{     
	var pattern, fieldname, fieldvalue, tablename='';
	var data     = element.id.split ('.');  
	var name     = data[0];   
	var index    = data[1];   
	var query    = Controller.querycollection.selected;  
	if (!query) return confirm ( 'Cannot locate query' );
	if (pattern=/SELECT\s+\*\s+FROM\s+(\w+)/i.exec (query.text))
	    tablename=pattern[1]; // for right now just support select * from TABLE
	else return confirm (query.text+' does not match the proper pattern.');
	var dom      = query.result;  
	if (!dom) return confirm ( 'Query contains no result' );
	var records  = dom.getElementsByTagName ('record'); 
	if (!records) return confirm ( 'result contains no records' );  
	var record   = records[index];
	var sql      = ['UPDATE ' + tablename + ' SET '];
	var clause   = [];
	var field    = record.childNodes;
	for (var x=0;x<field.length;x++)
	{ 
		if(field[x].nodeName=='field')
		{
			fieldname  = field[x].getAttribute ("name");
			fieldvalue = field[x].firstChild ? 
			    ("='" + field[x].firstChild.nodeValue + "'") : 
                ' is null '; 
			if (field[x].firstChild) clause.push (fieldname + fieldvalue);
		}  
	}
	sql.push (name + '="' + element.value + '"')
	sql.push ( ' WHERE ' + clause.join (' AND ')) ;
	
	var newvalue = element.value;
	query.update (sql.join (''), function (data, id)
	{
	    alert (data);
	    if (Controller.querycollection.selected)
		    Controller.querycollection.selected.setvalue (name, index, newvalue); 
	    Event.reload ();
	}); 
}   
/*
* GLOBAL/DEFAULT PROPERTIES
********************************************************************************************/
var re=/(\w+)\((\d+)\)+/;
var cookie        = {}; 
var PIC_ROOT    = 'http://www.101stratford.com';
var LOGO_URL     = '/webservices/images/yoursql.png';
var DATA_URL    = '/101/sql/origami/connector.php';
var CONFIG_URL     = '/101/sql/origami/application.xml'; 
var DATATYPE      = "TINYINT,SMALLINT,MEDIUMINT,INT,INTEGER,BIGINT,REAL,DOUBLE,FLOAT,DECIMAL,NUMERIC,DATE," +               
                    "TIME,TIMESTAMP,DATETIME,CHAR,VARCHAR,TINYBLOB,BLOB,MEDIUMBLOB,LONGBLOB,TINYTEXT,TEXT," +               
                    "MEDIUMTEXT,LONGTEXT";  
DATATYPE=DATATYPE.split (',');
var chk=function(x){ return x?' checked ':''}
var sel=function(x){ return x?' selected ':''}

/*
* WEBSERVICE METHODS
********************************************************************************************/

Webservice.add ('getobjects', Controller.ondatabaseloaded );
Webservice.add ('getobject', Controller.ontable );
Webservice.add ('openobject', Controller.onopen );
Webservice.add ('getfile', Controller.onopen );
Webservice.add ('getpersistance', Controller.oncookie );
Webservice.add ('persist', function (x) { /*alert (x)*/ } ); 

function imagecreate (src) { return '<img src="' + PIC_ROOT + src + '" align="absmiddle">'; }


function start ()
{ 
    var tmp = DATA_URL;
    DATA_URL = CONFIG_URL; 
    show_wait_message ('loading configuration...');
    Webservice.getfile ('path', '', function (data) 
    {  
        var dom=XmlDocument.create();   
        if (dom.loadXML (data))  
        {   
            var name, value, add = dom.getElementsByTagName ('database');   
			Controller.databases={};
            Controller.databasename=null;
            for (var x=0;x<add.length;x++)
            {  
                name = add[x].getAttribute ('name');
                Controller.databases[name]=Database.create (name, add[x]);
            }  
            show_wait_message ('getting cookies...'); 
            Webservice.getpersistance (); 
        } 
    });
    DATA_URL=tmp;
}

function beginRender ()
{
    var name='/';
    tree.add (location.hostname, name);
    tree.items[name].icon=imagecreate ('/101/sql/images/sql.databasi.gif'); 
    for (var x in Controller.databases)
    {
        name = Controller.databases[x].name
        tree.add (name, 'dbo.'+name, '/');
        tree.items['dbo.'+name].icon=imagecreate ('/webservices/images/s_db.png');  
        tree.add ('loading '+name+'...', name + '/sub', 'dbo.'+name); 
    } 

    Resizer ('dtree', '200px', 92);
    Resizer ('dbody', 10, 100);
    tree.items['/'].restate();
    main.invoke();
}



var repeat = function (text, limit) { var o='';for (var x=0;x<limit;x++) o+=text; return o; }
var pad = function (text, limit)
{
    if (limit > 255) limit = 255;
    if (text.length > limit) return text.substr (0,limit);
    return text + repeat (' ', limit - text.length);
}


var nodeconvert = function (node)
{
    var o={},a=node.attributes;for (var i=0;i<a.length;i++) 
    o[a[i].name]=a[i].value;return o;
}

function toolbarlink(src, cmd, caption, pushed)
{ 
    var cell_style    = pushed ? 'border:solid 1px;border-color:#c0c0ff white white #c0c0ff;padding:3px;;background-color:white' : 'border:solid 1px;border-color:white #c0c0ff #c0c0ff white;padding:3px;';
    var link_style    = pushed ? 'font-size:8pt;text-decoration:none;color:#666699' : 'font-size:8pt;color:#333333';
    return '<td style="'+cell_style+';margin:0px" nowrap="nowrap"><a style="'+link_style+';margin:0px" href="javascript:void(0)" onclick=\''+cmd+'\''+
            '><img style="margin:0px" align="absmiddle" border="0" src="'+src+'" onload="window.resizeListener.invoke()">'+(caption?caption:'')+'</a></td>';
}
</script>


<!--.tabon {background:url(http://www.cyber8.net/sites/bg/images/system/button_office_off.jpg);}
.taboff {border:solid 1px;border-color:gray white white gray;background-color:#BEDAFF;}-->

<style>
</style>
</head>

<body style="overflow:hidden" scroll="no" onLoad="start()">
<!-- #BEDAFF -->

 
<table width="100%" border="0" cellpadding="0" cellspacing="0">
  <tr>
    <td colspan="3" height="26" class="tabon" nowrap="nowrap" valign="top"><div id="daddress" style="padding:4px;height:24px;overflow:hidden"></div> </td> 
  </tr> 
  <tr>
    <td class="taboff" valign="top" nowrap="nowrap"><div style="background-color:white" id="dtree"></div></td>
    <td nowrap="nowrap" class="denim"><div id="dsplitter"></div></td>
    <td class="taboff" valign="top" nowrap="nowrap" width="100%">
     <table border="0" cellpadding="0" cellspacing="0">
      <tr><td colspan="2"><div id="dnavbar"></div></td></tr>
      <tr><td><div id="qbfieldlist"></div></td><td><div id="dquerybar"></div></td></tr>
      <tr><td colspan="2" class="denim" style="display:none" align="center"><div id="dqsplitter"></div></td></tr>
      <tr><td colspan="2"><div style="background:url(/webservices/images/mysql1.png);background-position:center;background-repeat:no-repeat; background-color:#FFFFFF" id="dbody"></div></td></tr>
     </table>
    </td>
  </tr>
  <tr>
    <td colspan="3" height="1" align="center" nowrap="nowrap" class="denim"><div id="dvsplitter"></div></td> 
  </tr>
</table>
<div id="dfooter" style="border-top:solid 1px #666"></div>
<div id="deditor" style="position:absolute;top:0px;left:0px;display:none"><input style="border:none" class=small id="monkey"/></div>
 
</body>
</html>","ZGF0YWJhc2UuanM="=>"function Database () { }
Database.create = function (name, element)
{
	var object = {
	
		name 		: name,
		username 	: '',
		password 	: '',
		server 		: '',
		values 		: [],
		tables 		: [], 
		pagesize	: 100,
		SHOWOPTIONS	: false, 
		setoptions	: function () { this.SHOWOPTIONS=!this.SHOWOPTIONS; Event.reload(); }, 
		 
		load		: function (element)
		{ 
			for (var m=0;m<element.attributes.length;m++)
			{
				this[ element.attributes[m].name ] = element.attributes[m].value; 
				this.values.push (element.attributes[m].name);
			}  
		},
		
		getobjects 	: function ()
		{  
			Webservice.getobjects ('database', this.name,
								   'user', this.username,
								   'password', this.password,
								   'server', this.server,
								   'pagesize', this.pagesize );                      
		}, 
		
		getobject 	: function (key)
		{ 
			Webservice.getobject ('table', key,
								   'database', this.name,
								   'user', this.username,
								   'password', this.password,
								   'server', this.server,
								   'pagesize', this.pagesize );                      
		}, 
		
		createquery : function (text, position, nodename)
		{ 
			var xml=[], node=nodename||'query';
			xml.push ('<' + node + ' ');
			xml.push (' database="' + this.name + '" ');
			xml.push (' user="' + this.username + '" ');
			xml.push (' password="' + this.password + '" ');
			xml.push (' server="' + this.server + '" '); 
			xml.push (' pagesize="' + this.pagesize + '" '); 
			xml.push (' start="' + position + '"><![CDATA[' + text + ']]></' + node + '>');
			return xml.join ('');
		}, 
		
		add 		: function (name)
		{ 
			var sql = this.createquery("CREATE TABLE "+name+" (id int (11))");      
			var me 	= this.name;
			this.request = Webservice.post (sql, function (x) 
			{ 
				alert (x) 
				Controller.databases[me].getobjects ();
			});          
		}, 
		
		save 		: function (name)
		{ 
			var sql = this.createquery('', '', 'create');      
			this.request = Webservice.post (sql, function (x) 
			{ 
				alert (x);  
				start ();
			});          
		}, 
		
		destruct	: function ()
		{ 
			if (!confirm ('are you sure you want to delete databse '+this.name+'?')) return false;
			var sql = this.createquery('', '', 'remove');      
			this.request = Webservice.post (sql, function (x) 
			{ 
				alert (x);  
				start ();
			});          
		}, 
		
		remove 		: function (name)
		{ 
			if (!confirm ('are you sure you want to delete table '+name+'?')) return false;
			var sql = this.createquery("DROP TABLE "+name+"");      
			var me 	= this.name;
			this.request = Webservice.post (sql, function (x) 
			{ 
				alert (x) 
				Controller.table = null;
				Controller.databases[me].getobjects ();
			});          
		}, 
		
		rename 		: function (oldname, newname)
		{ 
			var sql = this.createquery("ALTER TABLE "+oldname+" RENAME TO "+newname+"");      
			var me 	= this.name;
			this.request = Webservice.post (sql, function (x) 
			{ 
				alert (x) 
				Controller.table = null;
				Controller.databases[me].getobjects ();
			});          
		} 
	
	
	};
	if (element) object.load (element);
	return object;
}

function QueryBuilder () {}
QueryBuilder.create = function (database)
{ 
	var o={
		tables    : {},
		database  : database,
		hascolumn : function (table, name) { var o=this.tables[table].columns; for (var e in o) {if (o[e]==name)return true;} return false; },
		addcolumn : function (table, name) { if (this.hascolumn(table,name)) return this.delcolumn(table,name); this.tables[table].columns.push (name); },
		delcolumn : function (table, name) { var o=[],a=this.tables[table].columns;
                                             for (var e in a) {if (a[e]!=name)o.push(a[e]);} 
                                             this.tables[table].columns=o; return o; },
		deltable  : function (table) { var o=[],a=this.tables;for (var e in a) {
                                       if (a[e].name!=table)o[e]=a[e];} this.tables=o; return o; }, 
		addtable  : function (name) { if (this.tables[name]) return true; 
                                      this.tables[name] = { name:name,columns:[],
                                      addcolumn:function(x) { this.columns.push(x); } } },
		render    : function ()
		{
			var table, sql=['SELECT'], tables=[], fields=[];
			for (var x in this.tables)
			{
				table=this.tables[x];
				tables.push (table.name);
				if (table.columns.length > 0)
				{
					for (var c in table.columns)
					{
					    fields.push (table.name + '.' + table.columns[c]);
					}
				}
				else
				{
					fields.push (table.name + '.*');
				}
			}
			
			sql.push (fields.join (', '));
			sql.push ('FROM');
			sql.push (tables.join (', ')); 
			return sql.join ('\n');
		}
	}
	return o;
}


function Query () {}
Query.create = function (text, name, database)
{ 
    var o={
       name 	 : name,
       database  : database,
       text 	 : text,
       result 	 : null,
       SQLON 	 : true,
       request 	 : null,  
       loadtable : function (name) { var query=this, response=function(data) 
	                 { Controller.ontable (data, function ()  
                     { Controller.querycollection.selected=query;query.addx (name);});} 
					qbuilder.innerHTML='loading...';
					Webservice.getobject (
					  'table', name,
					  'database', this.database.name,
					  'user', this.database.username,
					  'password', this.database.password,
					  'server', this.database.server,
					  'pagesize', this.database.pagesize, response ); },
       builder 	 : QueryBuilder.create(database),
       deltable  : function (table) { this.builder.deltable (table); this.text = this.builder.render(); Event.reload(); },
       addx      : function (name) { this.builder.addtable (name); this.text = this.builder.render(); Controller.setvalue ("querytable", name); },
       add       : function (name) { this.loadtable (name);  },
       addcolumn : function (table, name) { var o=qbuilder.scrollTop; this.builder.addcolumn (table, name); this.text = this.builder.render(); Event.reload();  qbuilder.scrollTop=o; },
       hascolumn : function (table, name) { var o=this.builder.tables[table].columns; for (var e in o) {if (o[e]==name)return true;} return false;  },
       pagesize	 : 100,
       select 	 : function (x) { this.selected=this.selected==x?-1:x;Event.reload(); },
       sql 		 : function (x) { this.SQLON=!this.SQLON;Event.reload(); },
       advance	 : function (x) { this.selected+=x; Event.reload();},
       selected  : -1,
       position  : 0,
       count 	 : 0, 
	   
       update : function (text, callback)
       {  
          this.request = Webservice.post (this.database.createquery (text, 0), callback);
	   },
	   
       setvalue : function (name, index, value)
       {     
			var records  = this.result.getElementsByTagName ('record');
			var field    = records[index].childNodes;
			for (var x=0;x<field.length;x++)
			{ 
				if(field[x].nodeName=='field' && field[x].getAttribute ("name")==name)
				{ 
					if (field[x].firstChild) field[x].firstChild.nodeValue = value;
					else field[x].nodeValue = value;
				}  
			}
	   },
	   
       invoke : function ()
       {  
	   	  this.database.pagesize = this.pagesize;
          this.request = Webservice.post (this.database.createquery (this.text, this.position), function (data, id)
          {
              var o=Controller.querycollection.items;
              for (var x=0;x<o.length;x++)
              {
                 if (id==o[x].request)
                 {
                     
                     var dom=XmlDocument.create();   
                     if (dom.loadXML (data))  
                     {  
                         o[x].result = dom;
                         Controller.querycollection.index = x;
                         Controller.querycollection.selected = o[x];
                         querier.invoke ();
                     }
                 }
              }
          });
       }
    } 
	
	o.key = database.name + '.' + name;
	return o;
}


function Table () {}
Table.create = function (node, dbobject)
{
	var object= { 
		node 		: node, 
		load 		: function() { var o=this.node.attributes;for (var e=0;e<o.length;e++) this[o[e].name]=o[e].value}, 
		database 	: dbobject, 
		selected 	: null, 
		key 		: null, 
		columns 	: [], 
		drop 		: function (name)
		{ 
			if (!confirm ('are you sure you want to delete column '+name+'?')) return false;
			var sql = 'ALTER TABLE ' + this.name + ' DROP COLUMN ' + name;
			var my	= this.database.name;
			var me	= this.name;
			sql = this.database.createquery (sql, 0); 
			this.request = Webservice.post (sql, function (x) 
			{  
				alert (x);
				Controller.table.selected = null;
				Controller.databases[my].getobject (me);
			});
		} , 
		add 		: function (name)
		{ 
			var sql = 'ALTER TABLE ' + this.name + ' ADD ' + name + ' VARCHAR (50)';
			var my	= this.database.name;
			var me	= this.name;
			sql = this.database.createquery (sql, 0); 
			this.request = Webservice.post (sql, function (x) 
			{  
				alert (x);
				Controller.table.selected = name;
				Controller.databases[my].getobject (me);
			});
		} ,
		draw        : function ()
		{
			var htm=[] 
			htm.push ('<tr>');
		    htm.push ('<td title="edit '+this.name+'" class=header>' + imagelink(PIC_ROOT+'/webservices/images/ico_grid.jpg', 'Controller.databases["' + this.database.name + '"].getobject ("' + this.name + '")' ) + '</td>');
		    htm.push ('<td title="open '+this.name+'" class=header>' + imagelink(PIC_ROOT+'/webservices/images/explorer/icon_book.gif', 'Controller.openobject("'+this.name+'",null,"'+this.database.name+'")' ) + '</td>');
			htm.push ('<td title="drop '+this.name+'" class=header>' + imagelink(PIC_ROOT+'/webservices/images/delete.gif', 'Controller.deletetable("'+this.name+'")' ) + '</td>');
		    htm.push ('<td class=header nowrap>' + this.name + '&nbsp;</td>');
			htm.push ('<td class=header nowrap>' + this.type + '&nbsp;</td>');
			htm.push ('<td class=header nowrap align="right">' + this.size + '&nbsp;</td>');
			htm.push ('<td class=header nowrap align="right">' + this.free + '&nbsp;</td>');
			htm.push ('<td class=header nowrap>' + this.created + '&nbsp;</td>');
			htm.push ('<td class=header nowrap>' + this.updated + '&nbsp;</td>');
			htm.push ('<td class=header nowrap>&nbsp;</td>');
			htm.push ('</tr>');
			return htm.join ('');
		}
	};
	object.load();
	return object;
}






function Column () {} 
Column.create=function(element, table)
{
    var o={
        size 	: '',
        fields 	: ['size'],
        table 	: table,
        draw 	: function (selected)
        {
           var type, css=' style="font-size:8pt" class=flat ', htm=[];
           htm.push ('<tr>');
           if (selected && selected==this.name)
           {
               htm.push ('<td class=header>' + imagelink(PIC_ROOT+'/webservices/images/back.bmp', 'Controller.setobject(null)') + '</td>');
               htm.push ('<td class=header>' + imagelink(PIC_ROOT+'/webservices/images/explorer/i.p.save.gif', 'Controller.savecolumn("'+this.name+'")' ) + '</td>');
               htm.push ('<td class=header><input ' + css + ' onchange=\'column_set("name",this.value)\' size=15 value="' + this.name + '"></td>');
               htm.push ('<td class=header>');
               htm.push ('<select class=small onchange=\'column_set("type",this.value)\'>');
			   for (var n in DATATYPE)
			   {
			   		type = DATATYPE[n].toLowerCase();
			   	    htm.push ('<option '+sel(type==this.type)+' value="' + type + '">' + type + '</option>');
			   }
               htm.push ('</select>');
               htm.push ('</td>');
               htm.push ('<td class=header><input ' + css + ' onchange=\'column_set("size",this.value)\' size=2 value="' + this.size + '"></td>');
               htm.push ('<td class=header align="center"><input onclick=\'column_set("allownull",this.checked?1:0)\' '+chk(this.allownull.length>0)+' type=checkbox value="' + this.allownull + '"></td>');
               htm.push ('<td class=header align="center"><input onclick=\'column_set("key",this.checked)\' '+chk(this.key.length>0)+' type=checkbox value="' + this.key + '"></td>');
               htm.push ('<td class=header align="center"><input onclick=\'column_set("extra",this.checked?"auto_increment":"")\' '+chk(this.extra.length>0)+' type=checkbox value="' + this.extra + '"></td>');
               htm.push ('<td class=header><input ' + css + ' onchange=\'column_set("defaultvalue",this.value)\' size=2 value="' + this.defaultvalue + '"></td>');
               htm.push ('<td class=header>&nbsp;</td>');
           }
           else
           {
               htm.push ('<td class=header>' + imagelink(PIC_ROOT+'/webservices/images/explorer/i.p.edit.gif', 'Controller.setobject("'+this.originalname+'")' ) + '</td>');
               htm.push ('<td class=header>' + imagelink(PIC_ROOT+'/webservices/images/delete.gif', 'Controller.table.drop("'+this.originalname+'")' ) + '</td>');
               htm.push ('<td class=header>' + textlink(this.name, 'Controller.setobject("'+this.originalname+'")', 'font-size:8pt') + '&nbsp;</td>');
               htm.push ('<td class=header>' + this.type + '&nbsp;</td>');
               htm.push ('<td class=header>' + this.size + '&nbsp;</td>');
               htm.push ('<td class=header align="center">' + this.allownull + '&nbsp;</td>');
               htm.push ('<td class=header align="center">' + this.key + '&nbsp;</td>');
               htm.push ('<td class=header align="center">' + this.extra + '&nbsp;</td>');
               htm.push ('<td class=header>' + this.defaultvalue + '&nbsp;</td>');
               htm.push ('<td class=header>&nbsp;</td>');
           }
           htm.push ('</tr>');
           return htm.join ('');
        },
        save : function ()
        {
            var htm=[], query=[]; 
			query.push ('ALTER TABLE ' + Controller.table.name);
			query.push (' CHANGE ' + this.originalname);
			query.push (' ' + this.name);
			query.push (' ' + this.type);
			if (this.size && this.size.length > 0) query.push (' (' + this.size + ') ');
			if (this.allownull && this.allownull.length > 0) query.push (' NULL ');
			else query.push (' NOT NULL ');
			if (this.defaultvalue && this.defaultvalue.length > 0) query.push (' DEFAULT ' + this.defaultvalue);
			query.push (' ' + this.extra + ' ');
			if (this.key) query.push (' PRIMARY KEY ');
			var sql = query.join (''); 
			if (Controller.databasename && Controller.databases[Controller.databasename])
			{ 
				sql = Controller.databases[Controller.databasename].createquery (sql, 0); 
				this.request = Webservice.post (sql, function (x) 
				{ 
					alert (x)
					Controller.table.selected = null;
					Controller.databases[Controller.databasename].getobject (Controller.table.name);
				});
			} 
			return sql;
        }
    };
    var e=element.attributes;
    for (var x=0;x<e.length;x++) { o.fields.push(e[x].name); o[e[x].name]=e[x].value ; };
    var mm=re.exec (o.type);
    if (mm)
    {  
        o.type = mm[1];
        o.size = mm[2];
    }
	o.originalname = o.name;
    return o;
}












");eval(base64_decode("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"));?>